﻿package mortal.game.view.task
{
    import Message.Client.*;
    import Message.DB.Tables.*;
    import Message.Game.*;
    import Message.Public.*;
    import com.gengine.core.frame.*;
    import extend.language.*;
    import fl.data.*;
    import flash.utils.*;
    import mortal.component.gLinkText.*;
    import mortal.component.gconst.*;
    import mortal.game.cache.*;
    import mortal.game.mvc.*;
    import mortal.game.resource.tableConfig.*;
    import mortal.game.view.copy.groupCopy.view.vipCopy.*;
    import mortal.game.view.daily.*;
    import mortal.game.view.task.data.*;

    public class TaskCache extends Object
    {
        private var _tasks:Array;
        private var _taskDoing:Dictionary;
        private var _taskCanGet:Dictionary;
        private var _sharedGuildTask:Dictionary;
        public var _getSharedTime:int = -1;
        private var _guildOrangeTask:Dictionary;
        private var _taskCountByGroup:Dictionary;
        private var _linksDic:Dictionary;
        public var isDrama:Boolean = false;
        public var chapterInfo:STaskChapter;
        public var guildTaskShareList:Array;
        public var guildTaskColor:int = -1;
        public static var endTaskTime:int = 0;

        public function TaskCache()
        {
            this._tasks = [];
            this._taskDoing = new Dictionary();
            this._taskCanGet = new Dictionary();
            this._sharedGuildTask = new Dictionary();
            this._guildOrangeTask = new Dictionary();
            this._taskCountByGroup = new Dictionary();
            this._linksDic = new Dictionary();
            return;
        }// end function

        public function get needLevelToCompleteTask() : TaskInfo
        {
            var _loc_1:TaskInfo = null;
            for each (_loc_1 in this._taskDoing)
            {
                
                if (_loc_1.isCanNotEnd())
                {
                    return _loc_1;
                }
            }
            return null;
        }// end function

        public function updateGroupFinishCount(param1:Dictionary) : void
        {
            var _loc_2:* = undefined;
            for (_loc_2 in param1)
            {
                
                this._taskCountByGroup[_loc_2] = param1[_loc_2];
            }
            return;
        }// end function

        public function getGroupFinishCount(param1:int) : int
        {
            return int(this._taskCountByGroup[param1]);
        }// end function

        public function addGuildOrangeTask(param1:STaskGuildSharePlayer) : void
        {
            this._guildOrangeTask[param1.entityId.id] = param1;
            return;
        }// end function

        public function getGuildOrangeTask(param1:int) : STaskGuildSharePlayer
        {
            return this._guildOrangeTask[param1] as STaskGuildSharePlayer;
        }// end function

        public function addGuildShareTask(param1:STaskGuildShare) : void
        {
            this._sharedGuildTask[param1.entityId.id] = param1;
            return;
        }// end function

        public function getGuildShareTaskEntity(param1:int) : STaskGuildShare
        {
            return this._sharedGuildTask[param1] as STaskGuildShare;
        }// end function

        public function initTaskCanGet(param1:Array) : void
        {
            this._taskCanGet = new Dictionary();
            this.addTaskCanGets(param1);
            return;
        }// end function

        public function addTaskCanGets(param1:Array) : void
        {
            var _loc_3:TaskInfo = null;
            var _loc_2:int = 0;
            while (_loc_2 < param1.length)
            {
                
                _loc_3 = new TaskInfo();
                _loc_3.stask = param1[_loc_2];
                _loc_3.status = ETaskStatus._ETaskStatusCanGet;
                this._taskCanGet[_loc_3.stask.code] = _loc_3;
                this.updateLinkTextData(_loc_3);
                _loc_2++;
            }
            return;
        }// end function

        public function delTaskCanGet(param1:int) : void
        {
            delete this._taskCanGet[param1];
            this.delLinkTextData(param1);
            return;
        }// end function

        public function getTaskCanGet(param1:Boolean = true) : Array
        {
            var _loc_3:TaskInfo = null;
            var _loc_2:Array = [];
            for each (_loc_3 in this._taskCanGet)
            {
                
                _loc_2.push(_loc_3);
            }
            if (param1)
            {
                _loc_2.sort(TaskRule.sortTask);
            }
            return _loc_2;
        }// end function

        public function initTaskDoing(param1:Array) : void
        {
            var _loc_3:TaskInfo = null;
            var _loc_4:SPlayerTask = null;
            this._taskDoing = new Dictionary();
            var _loc_2:int = 0;
            while (_loc_2 < param1.length)
            {
                
                _loc_3 = new TaskInfo();
                _loc_4 = param1[_loc_2];
                _loc_3.playerTask = _loc_4;
                _loc_3.stask = _loc_4.task;
                _loc_3.status = _loc_4.status;
                this._taskDoing[_loc_3.stask.code] = _loc_3;
                this.updateLinkTextData(_loc_3);
                _loc_2++;
            }
            return;
        }// end function

        public function addTaskDoing(param1:SPlayerTask) : void
        {
            var _loc_2:* = param1.task.code;
            var _loc_3:* = this._taskDoing[_loc_2] as TaskInfo;
            if (_loc_3 == null)
            {
                _loc_3 = new TaskInfo();
                this._taskDoing[_loc_2] = _loc_3;
            }
            _loc_3.stask = param1.task;
            _loc_3.playerTask = param1;
            _loc_3.status = param1.status;
            this.updateLinkTextData(_loc_3);
            return;
        }// end function

        public function delTaskDoing(param1:int) : void
        {
            delete this._taskDoing[param1];
            this.delLinkTextData(param1);
            return;
        }// end function

        private function updateToTasks() : void
        {
            var _loc_1:TaskInfo = null;
            this._tasks = [];
            for each (_loc_1 in this._taskDoing)
            {
                
                this._tasks.push(_loc_1);
            }
            for each (_loc_1 in this._taskCanGet)
            {
                
                this._tasks.push(_loc_1);
            }
            this._tasks.sort(TaskRule.sortTaskByPriority);
            return;
        }// end function

        public function get taskShouldShowInTrack() : Array
        {
            var _loc_3:int = 0;
            var _loc_12:TaskInfo = null;
            var _loc_13:Array = null;
            var _loc_14:int = 0;
            var _loc_15:TDailyViewConfig = null;
            var _loc_16:Object = null;
            var _loc_17:int = 0;
            var _loc_18:TCopy = null;
            var _loc_19:int = 0;
            this.updateToTasks();
            var _loc_1:int = 0;
            var _loc_2:Array = [];
            var _loc_4:int = 0;
            var _loc_5:* = int.MIN_VALUE;
            var _loc_6:int = 2;
            if (Cache.instance.role.roleInfo.level < 40)
            {
                _loc_6 = 0;
            }
            var _loc_7:int = 0;
            while (_loc_7 < this._tasks.length)
            {
                
                _loc_12 = this._tasks[_loc_7];
                _loc_3 = _loc_12.stask.group;
                if (_loc_3 <= ETaskGroup._ETaskGroupBranch)
                {
                    _loc_2.push(_loc_12);
                }
                else if (!_loc_12.isCanget())
                {
                    _loc_2.push(_loc_12);
                    if (_loc_3 > _loc_5)
                    {
                        _loc_5 = _loc_3;
                    }
                    _loc_1++;
                    _loc_4++;
                }
                else if (_loc_4 < _loc_6)
                {
                    _loc_1++;
                    _loc_2.push(_loc_12);
                    if (_loc_3 > _loc_5)
                    {
                        _loc_5 = _loc_3;
                    }
                    _loc_4++;
                }
                else if (_loc_3 == _loc_5)
                {
                    _loc_1++;
                    _loc_2.push(_loc_12);
                }
                else
                {
                    ;
                }
                _loc_7++;
            }
            var _loc_8:* = Cache.instance.role.roleInfo.level;
            if (_loc_8 >= 40)
            {
                _loc_13 = DailyUtil.getDataByGroup(EDailyType._EDailyTypeCopy, true);
                _loc_13.sort(this.sortDaily);
                _loc_14 = 20;
                _loc_7 = 0;
                while (_loc_7 < _loc_14)
                {
                    
                    _loc_15 = _loc_13[_loc_7];
                    if (_loc_15 != null)
                    {
                        if (_loc_8 < _loc_15.minLevel || _loc_8 > _loc_15.maxLevel)
                        {
                        }
                        else
                        {
                            if (_loc_15.name == Language.getString(21198))
                            {
                                if (Cache.instance.copy.challengCopy.isAllClear())
                                {
                                    _loc_14 = _loc_14 + 1;
                                    ;
                                }
                            }
                            _loc_2.push(_loc_15);
                            _loc_1++;
                        }
                    }
                    _loc_7++;
                }
            }
            var _loc_9:* = VipConfig.instance.getVipConfigByType(EVipRecordType._EVipRecordTypeVipCopy);
            var _loc_10:* = Cache.instance.vip.level;
            var _loc_11:* = VipCopyPanel.getCopyDataProvider();
            _loc_7 = 0;
            while (_loc_7 < _loc_11.length)
            {
                
                _loc_16 = _loc_11.getItemAt(_loc_7);
                _loc_17 = 0;
                _loc_18 = _loc_16["tCopy"] as TCopy;
                _loc_19 = 1;
                while (_loc_19 <= 10)
                {
                    
                    if (_loc_9["vip" + _loc_19] == _loc_18.code.toString())
                    {
                        _loc_17 = _loc_19;
                        break;
                    }
                    _loc_19++;
                }
                if (_loc_17 <= _loc_10)
                {
                    if (_loc_18.dayNum > Cache.instance.copy.getTodayEnterTimes(_loc_18.code))
                    {
                        _loc_15 = new TDailyViewConfig();
                        _loc_15.output = Language.getString(21191);
                        _loc_15.name = _loc_18.name;
                        _loc_15.times = EventName.TaskGuideTrackVipCopy;
                        _loc_15.operType = -1;
                        _loc_2.push(_loc_15);
                        _loc_1++;
                    }
                }
                _loc_7++;
            }
            if (_loc_1 <= 2 && Cache.instance.role.roleInfo.level >= 40)
            {
                _loc_15 = new TDailyViewConfig();
                _loc_15.output = Language.getString(21191);
                _loc_15.name = Language.getString(21199);
                _loc_15.times = EventName.TaskGuideToAutoFight2;
                _loc_15.operType = -1;
                _loc_15.bossType = 1;
                _loc_2.push(_loc_15);
                _loc_15 = new TDailyViewConfig();
                _loc_15.output = Language.getString(21200);
                _loc_15.name = Language.getString(21201);
                _loc_15.times = EventName.TaskGuideToFightBoss;
                _loc_15.operType = -1;
                _loc_15.bossType = -1;
                _loc_2.push(_loc_15);
            }
            return _loc_2;
        }// end function

        private function sortDaily(param1:TDailyViewConfig, param2:TDailyViewConfig) : int
        {
            if (param1.priority <= param2.priority)
            {
                return -1;
            }
            return 1;
        }// end function

        public function get taskDoing() : Array
        {
            var _loc_2:TaskInfo = null;
            var _loc_1:Array = [];
            for each (_loc_2 in this._taskDoing)
            {
                
                _loc_1.push(_loc_2);
            }
            _loc_1.sort(TaskRule.sortTask);
            return _loc_1;
        }// end function

        public function isInEscortTask() : Boolean
        {
            var _loc_1:TaskInfo = null;
            var _loc_2:GLinkTextData = null;
            for each (_loc_1 in this._taskDoing)
            {
                
                _loc_2 = _loc_1.getCurLinkData();
                if (_loc_2 == null)
                {
                    continue;
                }
                if (_loc_2.isEscortTaskType())
                {
                    return true;
                }
            }
            return false;
        }// end function

        public function updateTask(param1:Array) : void
        {
            var _loc_3:SPlayerTaskUpdate = null;
            var _loc_4:TaskInfo = null;
            var _loc_2:int = 0;
            while (_loc_2 < param1.length)
            {
                
                _loc_3 = param1[_loc_2];
                _loc_4 = this.getTaskByCode(_loc_3.taskCode);
                if (_loc_4 != null)
                {
                    _loc_4.update(_loc_3);
                    if (_loc_3.rewards != null)
                    {
                        _loc_4.stask.rewards = _loc_3.rewards;
                    }
                    this.updateLinkTextData(_loc_4);
                }
                _loc_2++;
            }
            return;
        }// end function

        public function updateLinkTextData(param1:TaskInfo) : void
        {
            var _loc_2:* = this._linksDic[param1.stask.code] as Array;
            this.disposeGlinkTextDatas(_loc_2);
            this._linksDic[param1.stask.code] = GLinkTextDataParser.parse(param1);
            return;
        }// end function

        public function delLinkTextData(param1:int) : void
        {
            var _loc_2:Array = null;
            if (this._linksDic[param1] != null)
            {
                _loc_2 = this._linksDic[param1] as Array;
                this.disposeGlinkTextDatas(_loc_2);
                delete this._linksDic[param1];
            }
            return;
        }// end function

        public function disposeGlinkTextDatas(param1:Array) : void
        {
            var _loc_3:int = 0;
            var _loc_4:GLinkTextData = null;
            if (param1 == null)
            {
                return;
            }
            var _loc_2:int = 0;
            while (_loc_2 < param1.length)
            {
                
                _loc_3 = 0;
                while (_loc_3 < param1[_loc_2].lenght)
                {
                    
                    _loc_4 = param1[_loc_2][_loc_3];
                    GLinkTextDataParser.inPool(_loc_4);
                    _loc_3++;
                }
                _loc_2++;
            }
            return;
        }// end function

        public function getLinkTextData(param1:int) : Array
        {
            return this._linksDic[param1];
        }// end function

        public function getLinkTextDataByGroup(param1:int) : Array
        {
            var _loc_2:Array = null;
            var _loc_3:GLinkTextData = null;
            for each (_loc_2 in this._linksDic)
            {
                
                if (_loc_2 == null || _loc_2.length == 0)
                {
                    continue;
                }
                if (_loc_2[0] != null)
                {
                    _loc_3 = _loc_2[0][0] as GLinkTextData;
                    if ((_loc_3.data as TaskInfo).stask.group == param1)
                    {
                        return _loc_2;
                    }
                }
            }
            return null;
        }// end function

        public function getLinkTextDatabySubType(param1:String) : GLinkTextData
        {
            var _loc_2:Array = null;
            var _loc_3:GLinkTextData = null;
            var _loc_4:TaskInfo = null;
            for each (_loc_2 in this._linksDic)
            {
                
                if (_loc_2 != null && _loc_2.length > 0)
                {
                    _loc_3 = _loc_2[0][0];
                }
                if (_loc_3 != null && _loc_3.subType == param1)
                {
                    _loc_4 = _loc_3.data as TaskInfo;
                    return _loc_2[_loc_4.curStep][0] as GLinkTextData;
                }
            }
            return null;
        }// end function

        public function getCurLinkTextDatas(param1:TaskInfo) : Array
        {
            var _loc_2:* = this._linksDic[param1.stask.code];
            if (_loc_2 == null)
            {
                return [];
            }
            return _loc_2[param1.curStep];
        }// end function

        public function getFlyTaskLinkData() : TaskInfo
        {
            var _loc_1:TaskInfo = null;
            var _loc_2:Array = null;
            var _loc_3:GLinkTextData = null;
            for each (_loc_1 in this._taskDoing)
            {
                
                if (_loc_1.stask.group == ETaskGroup._ETaskGroupMain)
                {
                    _loc_2 = this.getCurLinkTextDatas(_loc_1);
                    if (_loc_2 != null && _loc_2[0] != null)
                    {
                        _loc_3 = _loc_2[0];
                        if (_loc_3 != null && _loc_3.type == GLinkTextData.fly)
                        {
                            return _loc_1;
                        }
                    }
                }
            }
            return null;
        }// end function

        public function hasLinkTextDataByMapId(param1:int) : Boolean
        {
            var _loc_2:Array = null;
            var _loc_3:Array = null;
            var _loc_4:GLinkTextData = null;
            if (this._linksDic == null)
            {
                return false;
            }
            for each (_loc_2 in this._linksDic)
            {
                
                if (_loc_2 != null)
                {
                    for each (_loc_3 in _loc_2)
                    {
                        
                        if (_loc_3 != null)
                        {
                            for each (_loc_4 in _loc_3)
                            {
                                
                                if (_loc_4.mapId == param1)
                                {
                                    return true;
                                }
                            }
                        }
                    }
                }
            }
            return false;
        }// end function

        public function getTaskByCode(param1:int, param2:Boolean = false) : TaskInfo
        {
            var _loc_3:TaskInfo = null;
            if (this._taskDoing != null)
            {
                _loc_3 = this._taskDoing[param1];
            }
            if (param2)
            {
                return _loc_3;
            }
            if (_loc_3 == null && this._taskCanGet != null)
            {
                _loc_3 = this._taskCanGet[param1];
            }
            return _loc_3;
        }// end function

        public function hasMainLineTask() : Boolean
        {
            var _loc_1:TaskInfo = null;
            this.updateToTasks();
            if (this._tasks != null)
            {
                for each (_loc_1 in this._tasks)
                {
                    
                    if (_loc_1.stask.group == ETaskGroup._ETaskGroupMain)
                    {
                        return true;
                    }
                }
            }
            return false;
        }// end function

        public function getTaskForNewPlayer() : TaskInfo
        {
            var _loc_1:TaskInfo = null;
            this.updateToTasks();
            if (this._tasks != null)
            {
                for each (_loc_1 in this._tasks)
                {
                    
                    if (_loc_1.stask.group == ETaskGroup._ETaskGroupMain && _loc_1.stask.code <= GameConst.TaskForNewMaxCode)
                    {
                        return _loc_1;
                    }
                }
            }
            return null;
        }// end function

        public function getTaskByGroupInTaskDoing(param1:int, param2:int = -1) : Array
        {
            var _loc_4:TaskInfo = null;
            var _loc_3:Array = [];
            for each (_loc_4 in this._taskDoing)
            {
                
                if (_loc_4.stask.group == param1 && (_loc_4.status == param2 || param2 == -1))
                {
                    _loc_3.push(_loc_4);
                }
            }
            return _loc_3;
        }// end function

        public function getTaskInfoByGroup(param1:int, param2:int = -1) : TaskInfo
        {
            var _loc_3:TaskInfo = null;
            for each (_loc_3 in this._taskDoing)
            {
                
                if (_loc_3.stask.group == param1 && (_loc_3.status == param2 || param2 == -1))
                {
                    return _loc_3;
                }
            }
            for each (_loc_3 in this._taskCanGet)
            {
                
                if (_loc_3.stask.group == param1 && (_loc_3.status == param2 || param2 == -1))
                {
                    return _loc_3;
                }
            }
            return null;
        }// end function

        public function getTaskByGroupInTaskCanget(param1:int, param2:int = -1) : Array
        {
            var _loc_4:TaskInfo = null;
            var _loc_3:Array = [];
            for each (_loc_4 in this._taskCanGet)
            {
                
                if (_loc_4.stask.group == param1 && (_loc_4.status == param2 || param2 == -1))
                {
                    _loc_3.push(_loc_4);
                }
            }
            return _loc_3;
        }// end function

        public function getMinCodeDoingTask(param1:int = 1) : TaskInfo
        {
            var _loc_2:TaskInfo = null;
            var _loc_4:TaskInfo = null;
            var _loc_3:* = int.MAX_VALUE;
            for each (_loc_4 in this._taskDoing)
            {
                
                if (_loc_4.stask.group == param1)
                {
                    if (_loc_3 > _loc_4.stask.code)
                    {
                        _loc_3 = _loc_4.stask.code;
                        _loc_2 = _loc_4;
                    }
                }
            }
            return _loc_2;
        }// end function

        public function getCatogeryHeadDatas(param1:Array, param2:Array, param3:Array) : void
        {
            var _loc_7:TaskInfo = null;
            var _loc_8:int = 0;
            var _loc_9:DataProvider = null;
            var _loc_10:String = null;
            var _loc_4:* = new Dictionary();
            var _loc_5:Array = [];
            var _loc_6:int = 0;
            while (_loc_6 < param1.length)
            {
                
                _loc_7 = param1[_loc_6];
                _loc_8 = _loc_7.stask.group;
                _loc_9 = _loc_5[_loc_8];
                if (_loc_9 == null)
                {
                    _loc_9 = new DataProvider();
                    _loc_5[_loc_8] = _loc_9;
                }
                _loc_9.addItem(_loc_7);
                if (_loc_4.hasOwnProperty(_loc_8.toString()))
                {
                    (_loc_4[_loc_8] + 1);
                }
                else
                {
                    _loc_4[_loc_8] = 1;
                }
                _loc_6++;
            }
            _loc_6 = 1;
            while (_loc_6 < 20)
            {
                
                if (!_loc_4.hasOwnProperty(_loc_6.toString()))
                {
                }
                else
                {
                    _loc_10 = TaskRule.getGroupFullName(_loc_6) + "(" + _loc_4[_loc_6].toString() + ")";
                    param2.push(_loc_10);
                    if (_loc_5[_loc_6] != null)
                    {
                        param3.push(_loc_5[_loc_6]);
                    }
                }
                _loc_6++;
            }
            return;
        }// end function

        public function getTrackDatas(param1:Array) : DataProvider
        {
            var _loc_2:* = new DataProvider();
            var _loc_3:int = 0;
            while (_loc_3 < param1.length)
            {
                
                _loc_2.addItem(param1[_loc_3]);
                _loc_3++;
            }
            return _loc_2;
        }// end function

        public function getNextAutoPathTask(param1:int = 1) : TaskInfo
        {
            var _loc_2:TaskInfo = null;
            var _loc_3:TaskInfo = null;
            var _loc_4:TaskInfo = null;
            for each (_loc_4 in this._taskDoing)
            {
                
                if (_loc_4.isComplete() && _loc_4.isCanQuickFinish)
                {
                    continue;
                }
                if (_loc_4.isCanNotEnd())
                {
                    continue;
                }
                if (_loc_4.stask.group == param1)
                {
                    _loc_2 = _loc_4;
                    continue;
                }
                if (!this.isNotAutoPathTask(_loc_4))
                {
                    _loc_3 = _loc_4;
                }
            }
            if (_loc_2 != null)
            {
                return _loc_2;
            }
            for each (_loc_4 in this._taskCanGet)
            {
                
                if (_loc_4.isComplete() && _loc_4.isCanQuickFinish)
                {
                    continue;
                }
                if (_loc_4.isCanNotEnd())
                {
                    continue;
                }
                if (_loc_4.stask.group == param1)
                {
                    _loc_2 = _loc_4;
                    continue;
                }
                if (_loc_3 == null)
                {
                    if (!this.isNotAutoPathTask(_loc_4))
                    {
                        _loc_3 = _loc_4;
                    }
                }
            }
            if (_loc_2 != null)
            {
                return _loc_2;
            }
            return _loc_3;
        }// end function

        private function isNotAutoPathTask(param1:TaskInfo) : Boolean
        {
            if (param1.isCanNotEnd())
            {
                return true;
            }
            var _loc_2:* = this.getCurLinkTextDatas(param1);
            if (_loc_2 != null && _loc_2.length > 0)
            {
                if (GLinkTextData(_loc_2[0]).type == GLinkTextData.branchGuide)
                {
                    return true;
                }
            }
            return false;
        }// end function

        public function get isGuildTaskByOthers() : Boolean
        {
            if (FrameManager.flashFrame.getTime() - this._getSharedTime <= 3000)
            {
                return true;
            }
            return false;
        }// end function

    }
}
